/**
 * OpenAI 适配器
 * 用于将 OpenAI 格式的请求转换为百炼格式，并将百炼响应转换为 OpenAI 格式
 */
const { generateCompletion, generateChat, analyzeImage } = require('./bailian-api');
const axios = require('axios');
const fs = require('fs');
const path = require('path');
const { getConfig } = require('./config-manager');

/**
 * 将 OpenAI 聊天请求转换为百炼格式并调用百炼 API
 * @param {Object} options - OpenAI 格式的请求选项
 * @returns {Promise<Object>} - OpenAI 格式的响应
 */
async function chatCompletion(options) {
  try {
    // 提取参数
    const { messages, model, max_tokens, temperature, stream } = options;

    // 验证必要参数
    if (!messages || !Array.isArray(messages) || messages.length === 0) {
      throw new Error('Messages array is required');
    }

    // 如果请求流式响应，但我们不支持，则抛出错误
    if (stream) {
      throw new Error('Stream response is not supported yet');
    }

    // 检查是否包含图片，如果包含则使用图片分析 API
    const hasImage = messages.some(msg =>
      msg.content && Array.isArray(msg.content) &&
      msg.content.some(item => item.type === 'image_url')
    );

    let response;

    if (hasImage) {
      // 处理包含图片的请求
      const lastMessage = messages[messages.length - 1];

      // 提取文本和图片
      let prompt = '';
      let imageBase64 = '';

      if (Array.isArray(lastMessage.content)) {
        // 提取文本内容
        const textItems = lastMessage.content.filter(item => item.type === 'text');
        prompt = textItems.map(item => item.text).join('\n');

        // 提取图片内容
        const imageItems = lastMessage.content.filter(item => item.type === 'image_url');
        if (imageItems.length > 0) {
          const imageUrl = imageItems[0].image_url.url;

          // 如果是 base64 格式的图片
          if (imageUrl.startsWith('data:image')) {
            imageBase64 = imageUrl.split(',')[1];
          } else {
            // 如果是 URL 格式的图片，尝试下载
            try {
              // 下载图片
              const imageResponse = await axios.get(imageUrl, { responseType: 'arraybuffer' });
              // 转换为 base64
              imageBase64 = Buffer.from(imageResponse.data).toString('base64');
            } catch (error) {
              throw new Error(`Failed to download image from URL: ${error.message}`);
            }
          }
        }
      } else {
        prompt = lastMessage.content;
      }

      // 调用图片分析 API
      response = await analyzeImage(
        imageBase64,
        prompt,
        max_tokens || 1024,
        temperature || 0.7
      );
    } else {
      // 处理纯文本对话
      // 调用百炼聊天 API
      response = await generateChat(
        messages,
        max_tokens || 1024,
        temperature || 0.7
      );
    }

    // 将百炼响应转换为 OpenAI 格式
    return formatBailianToOpenAI(response, model || 'bailian-default');
  } catch (error) {
    console.error('OpenAI adapter error:', error);
    throw error;
  }
}

/**
 * 将 OpenAI 文本补全请求转换为百炼格式并调用百炼 API
 * @param {Object} options - OpenAI 格式的请求选项
 * @returns {Promise<Object>} - OpenAI 格式的响应
 */
async function textCompletion(options) {
  try {
    // 提取参数
    const { prompt, model, max_tokens, temperature, stream } = options;

    // 验证必要参数
    if (!prompt) {
      throw new Error('Prompt is required');
    }

    // 如果请求流式响应，但我们不支持，则抛出错误
    if (stream) {
      throw new Error('Stream response is not supported yet');
    }

    // 调用百炼文本补全 API
    const response = await generateCompletion(
      prompt,
      max_tokens || 1024,
      temperature || 0.7
    );

    // 将百炼响应转换为 OpenAI 格式
    return formatBailianToOpenAI(response, model || 'bailian-default', true);
  } catch (error) {
    console.error('OpenAI adapter error:', error);
    throw error;
  }
}

/**
 * 将百炼响应格式转换为 OpenAI 格式
 * @param {Object} bailianResponse - 百炼 API 响应
 * @param {string} model - 模型名称
 * @param {boolean} isCompletion - 是否为文本补全（而非聊天）
 * @returns {Object} - OpenAI 格式的响应
 */
function formatBailianToOpenAI(bailianResponse, model, isCompletion = false) {
  // 检查百炼响应是否成功
  if (bailianResponse.Code !== 'Success' || !bailianResponse.Data) {
    throw new Error(bailianResponse.Message || 'Bailian API error');
  }

  const content = bailianResponse.Data.Content || '';
  const tokenCount = bailianResponse.Data.TokenCount || 0;

  // 创建 OpenAI 格式的响应
  if (isCompletion) {
    // 文本补全格式
    return {
      id: `cmpl-${Date.now()}`,
      object: 'text_completion',
      created: Math.floor(Date.now() / 1000),
      model,
      choices: [
        {
          text: content,
          index: 0,
          logprobs: null,
          finish_reason: 'stop'
        }
      ],
      usage: {
        prompt_tokens: 0, // 百炼不提供这个信息
        completion_tokens: tokenCount,
        total_tokens: tokenCount
      }
    };
  } else {
    // 聊天补全格式
    return {
      id: `chatcmpl-${Date.now()}`,
      object: 'chat.completion',
      created: Math.floor(Date.now() / 1000),
      model,
      choices: [
        {
          index: 0,
          message: {
            role: 'assistant',
            content
          },
          finish_reason: 'stop'
        }
      ],
      usage: {
        prompt_tokens: 0, // 百炼不提供这个信息
        completion_tokens: tokenCount,
        total_tokens: tokenCount
      }
    };
  }
}

module.exports = {
  chatCompletion,
  textCompletion
};
